const express = require('express');
const router = express.Router();
const multer = require('multer');
const FormData = require('form-data');
const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
const path = require('path');
const fs = require('fs');

// JWT验证中间件
const verifyToken = (req, res, next) => {
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({
      success: false,
      message: '未提供访问令牌'
    });
  }

  try {
    // 移除Bearer前缀
    const actualToken = token.startsWith('Bearer ') ? token.slice(7) : token;
    
    // 这里可以添加JWT验证逻辑
    // 暂时简单检查token是否存在
    if (!actualToken) {
      return res.status(401).json({
        success: false,
        message: '无效的访问令牌'
      });
    }
    
    next();
  } catch (error) {
    return res.status(401).json({
      success: false,
      message: '令牌验证失败'
    });
  }
};

// 文档提取器相关库
const pdfParse = require('pdf-parse');
const mammoth = require('mammoth');

// 文档提取器功能
const extractDocumentContent = async (filePath, mimeType) => {
  try {
    console.log(`📄 开始提取文档内容: ${filePath}, 类型: ${mimeType}`);
    
    const fileBuffer = fs.readFileSync(filePath);
    let extractedText = '';
    
    if (mimeType === 'application/pdf') {
      // 提取PDF内容
      const pdfData = await pdfParse(fileBuffer);
      extractedText = pdfData.text;
      console.log(`📄 PDF提取完成，页数: ${pdfData.numpages}, 字符数: ${extractedText.length}`);
    } else if (mimeType === 'application/msword' || mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document') {
      // 提取Word文档内容
      const result = await mammoth.extractRawText({ buffer: fileBuffer });
      extractedText = result.value;
      console.log(`📄 Word文档提取完成，字符数: ${extractedText.length}`);
    } else {
      throw new Error(`不支持的文件类型: ${mimeType}`);
    }
    
    // 清理和格式化文本
    extractedText = extractedText
      .replace(/\s+/g, ' ')  // 合并多个空白字符
      .replace(/\n\s*\n/g, '\n')  // 合并多个空行
      .trim();
    
    console.log(`📄 文档内容提取完成，最终字符数: ${extractedText.length}`);
    return extractedText;
    
  } catch (error) {
    console.error('❌ 文档提取失败:', error);
    throw new Error(`文档内容提取失败: ${error.message}`);
  }
};

// Dify API 配置
const DIFY_API_BASE_URL = 'http://127.0.0.1/v1';
const DIFY_API_KEY = 'app-TBsNAPhxFAhUe6A3rWoU0nZf';

// 配置文件上传存储
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    const uploadDir = path.join(__dirname, '../public/uploads/dify');
    // 确保上传目录存在
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }
    cb(null, uploadDir);
  },
  filename: function (req, file, cb) {
    // 文件名格式: dify-时间戳-随机数.扩展名
    const ext = path.extname(file.originalname);
    const filename = `dify-${Date.now()}-${Math.floor(Math.random() * 10000)}${ext}`;
    cb(null, filename);
  }
});

// 文件过滤器 - 只支持图片格式（根据Dify API文档）
const fileFilter = (req, file, cb) => {
  const allowedImageTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
  const allowedDocumentTypes = [
    'application/pdf',
    'application/msword',
    'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
  ];

  const allAllowedTypes = [...allowedImageTypes, ...allowedDocumentTypes];

  if (allAllowedTypes.includes(file.mimetype)) {
    cb(null, true);
  } else {
    cb(new Error('支持的文件格式：图片（JPEG、PNG、GIF、WebP）和文档（PDF、DOC、DOCX、TXT、CSV）'), false);
  }
};

// 创建上传中间件
const upload = multer({
  storage: storage,
  fileFilter: fileFilter,
  limits: {
    fileSize: 10 * 1024 * 1024 // 10MB 限制
  }
});

/**
 * 文件上传到 Dify API
 * POST /dify/upload-file
 */
router.post('/upload-file', verifyToken, upload.single('file'), async (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ 
        success: false,
        error: '没有上传文件' 
      });
    }

    console.log('📁 接收到文件上传请求:', {
      originalname: req.file.originalname,
      mimetype: req.file.mimetype,
      size: req.file.size,
      path: req.file.path
    });

    // 处理文件名，避免中文文件名问题
    const originalName = req.file.originalname;
    const ext = path.extname(originalName);
    const baseName = path.basename(originalName, ext);
    
    // 如果文件名包含中文，转换为英文
    let safeFileName = originalName;
    if (/[\u4e00-\u9fff]/.test(originalName)) {
      const timestamp = Date.now();
      safeFileName = `file_${timestamp}${ext}`;
      console.log(`📝 检测到中文文件名，转换为: ${originalName} -> ${safeFileName}`);
    }
    
    // 创建 FormData 发送到 Dify
    const formData = new FormData();
    formData.append('file', fs.createReadStream(req.file.path), {
      filename: safeFileName,
      contentType: req.file.mimetype
    });
    formData.append('user', 'user-123');

    console.log('🚀 正在上传到 Dify API...');

    // 发送到 Dify API
    console.log('📤 发送到 Dify API，文件信息:', {
      filename: req.file.originalname,
      mimetype: req.file.mimetype,
      size: req.file.size
    });
    
    const response = await fetch(`${DIFY_API_BASE_URL}/files/upload`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${DIFY_API_KEY}`,
        ...formData.getHeaders()
      },
      body: formData
    });

    if (!response.ok) {
      const errorText = await response.text();
      console.error('❌ Dify API 错误:', errorText);
      
      // 解析错误信息
      try {
        const errorData = JSON.parse(errorText);
        console.log('🔍 Dify API 错误详情:', errorData);
        
        if (errorData.code === 'unsupported_file_type') {
          throw new Error(`文件类型不支持: ${req.file.mimetype}。请尝试其他格式。`);
        } else if (errorData.code === 'file_too_large') {
          throw new Error(`文件太大: ${(req.file.size / 1024 / 1024).toFixed(2)}MB。最大支持10MB。`);
        } else if (errorData.code === 'invalid_param') {
          // 检查是否是中文文件名问题
          if (errorData.message && errorData.message.includes('File validation failed')) {
            throw new Error(`文件验证失败，可能是文件名包含中文字符。请尝试使用英文文件名。`);
          } else {
            throw new Error(`文件验证失败: ${errorData.message}。请检查文件格式和内容。`);
          }
        } else {
          throw new Error(`Dify API 错误: ${errorData.code} - ${errorData.message}`);
        }
      } catch (parseError) {
        console.log('⚠️ 无法解析错误信息:', parseError);
        throw new Error(`Dify API 错误: ${response.status} ${errorText}`);
      }
    }

    const result = await response.json();
    console.log('✅ Dify 文件上传成功:', result);

    // 检查是否是文档文件，如果是则提取内容
    let extractedContent = null;
    const isDocument = req.file.mimetype.startsWith('application/') && 
                      (req.file.mimetype === 'application/pdf' || 
                       req.file.mimetype === 'application/msword' || 
                       req.file.mimetype === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
    
    if (isDocument) {
      try {
        console.log('📄 检测到文档文件，开始提取内容...');
        extractedContent = await extractDocumentContent(req.file.path, req.file.mimetype);
        console.log('📄 文档内容提取成功，长度:', extractedContent.length);
      } catch (extractError) {
        console.error('❌ 文档内容提取失败:', extractError);
        // 即使提取失败，也继续上传文件
      }
    }

    // 等待一段时间确保文件处理完成
    console.log('⏳ 等待文件处理完成...');
    const waitTime = isDocument ? 30000 : 8000; // 文档文件等待30秒，图片文件等待8秒
    console.log(`⏳ 文件类型: ${req.file.mimetype}, 等待时间: ${waitTime/1000}秒`);
    await new Promise(resolve => setTimeout(resolve, waitTime));

    // 清理临时文件
    fs.unlink(req.file.path, (err) => {
      if (err) console.error('⚠️ 删除临时文件失败:', err);
      else console.log('🗑️ 临时文件已清理');
    });

    res.json({
      success: true,
      fileId: result.id,
      fileName: result.name,
      fileSize: result.size,
      mimeType: result.mime_type,
      extractedContent: extractedContent, // 添加提取的内容
      message: '文件上传成功'
    });

  } catch (error) {
    console.error('❌ 文件上传错误:', error);
    
    // 清理临时文件
    if (req.file && req.file.path) {
      fs.unlink(req.file.path, (err) => {
        if (err) console.error('⚠️ 删除临时文件失败:', err);
      });
    }
    
    res.status(500).json({ 
      success: false,
      error: '文件上传失败', 
      details: error.message 
    });
  }
});

/**
 * 发送聊天消息到 Dify 工作流
 * POST /dify/chat-messages
 */
router.post('/chat-messages', async (req, res) => {
  try {
    const { message, files, conversationId } = req.body;

    console.log('💬 接收到聊天请求:', {
      message: message?.substring(0, 50) + (message?.length > 50 ? '...' : ''),
      filesCount: files?.length || 0,
      conversationId
    });
    
    // 如果有文件，显示更详细的日志
    if (files && files.length > 0) {
      console.log('📎 文件详情:', files.map(f => ({
        fileId: f.fileId,
        type: f.type || 'unknown'
      })));
    }

    // 验证输入
    if (!message || message.trim() === '') {
      return res.status(400).json({
        success: false,
        error: '消息内容不能为空'
      });
    }

    // 构建请求体
    const requestBody = {
      inputs: {},
      query: message,
      response_mode: 'streaming',
      user: 'user-123',
      conversation_id: conversationId || ''
    };

    // 处理文件和文档内容
    if (files && files.length > 0) {
      const imageFiles = [];
      let documentContent = '';
      
      for (const file of files) {
        // 根据文件ID或文件信息判断文件类型
        let fileType = 'image'; // 默认类型
        
        // 如果有文件类型信息，使用它
        if (file.type) {
          if (file.type.startsWith('image/')) {
            fileType = 'image';
          } else if (file.type.startsWith('application/') || file.type.startsWith('text/')) {
            fileType = 'document';
          } else if (file.type.startsWith('audio/')) {
            fileType = 'audio';
          } else if (file.type.startsWith('video/')) {
            fileType = 'video';
          }
        }
        
        // 根据文件扩展名进一步判断
        if (file.name) {
          const ext = file.name.toLowerCase().split('.').pop();
          if (['pdf', 'doc', 'docx'].includes(ext)) {
            fileType = 'document';
          } else if (['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'].includes(ext)) {
            fileType = 'image';
          }
        }
        
        console.log(`📎 文件类型判断: ${file.name || 'unknown'} -> ${fileType}`);
        
        if (fileType === 'document') {
          // 文档文件：提取内容并添加到文本中
          if (file.extractedContent) {
            documentContent += `\n\n【文档内容 - ${file.name}】\n${file.extractedContent}`;
            console.log(`📄 添加文档内容: ${file.name}, 长度: ${file.extractedContent.length}`);
          } else {
            console.log(`⚠️ 文档文件 ${file.name} 没有提取的内容`);
          }
        } else {
          // 图片文件：添加到文件列表
          const fileObject = {
            type: fileType,
            transfer_method: 'local_file',
            upload_file_id: file.fileId
          };
          imageFiles.push(fileObject);
        }
      }
      
      // 如果有文档内容，添加到查询中
      if (documentContent) {
        requestBody.query = `${requestBody.query}\n\n${documentContent}`;
        console.log('📄 已将文档内容添加到查询中');
      }
      
      // 如果有图片文件，添加到文件列表
      if (imageFiles.length > 0) {
        requestBody.files = imageFiles;
        console.log('📎 包含图片文件:', requestBody.files.length, '个');
        console.log('📎 图片文件详情:', JSON.stringify(requestBody.files, null, 2));
      }
    }

    console.log('🚀 发送到 Dify 工作流:', {
      query: requestBody.query.substring(0, 50) + '...',
      filesCount: requestBody.files?.length || 0,
      conversationId: requestBody.conversation_id
    });

    // 发送到 Dify API
    const response = await fetch(`${DIFY_API_BASE_URL}/chat-messages`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${DIFY_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(requestBody)
    });

    if (!response.ok) {
      const errorText = await response.text();
      console.error('❌ Dify 聊天 API 错误:', errorText);
      
      // 解析错误信息，提供更详细的诊断
      try {
        const errorData = JSON.parse(errorText);
        console.log('🔍 Dify API 错误详情:', errorData);
        
        if (errorData.code === 'invalid_param' && errorData.message.includes('File validation failed')) {
          // 文件验证失败，提供更具体的建议
          const fileName = errorData.message.match(/for file: (.+)/)?.[1] || 'unknown';
          throw new Error(`文件验证失败: ${fileName}\n\n可能的原因：\n1. 文件格式不被Dify支持\n2. 文件内容有问题\n3. 文件处理时间不够\n\n建议：\n1. 尝试PDF格式\n2. 检查文件内容\n3. 稍后重试`);
        } else if (errorData.code === 'unsupported_file_type') {
          throw new Error(`文件类型不支持: ${errorData.message}`);
        } else {
          throw new Error(`Dify API 错误: ${errorData.code} - ${errorData.message}`);
        }
      } catch (parseError) {
        console.log('⚠️ 无法解析错误信息:', parseError);
        throw new Error(`Dify API 错误: ${response.status} ${errorText}`);
      }
    }

    console.log('✅ Dify API 响应成功，开始流式传输...');

    // 设置 SSE 响应头
    res.writeHead(200, {
      'Content-Type': 'text/plain; charset=utf-8',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive',
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Headers': 'Cache-Control'
    });

    // 转发流式响应
    let dataReceived = false;
    
    response.body.on('data', (chunk) => {
      dataReceived = true;
      res.write(chunk);
    });

    response.body.on('end', () => {
      console.log('📡 流式响应传输完成');
      res.end();
    });

    response.body.on('error', (error) => {
      console.error('❌ 流式响应错误:', error);
      if (!dataReceived) {
        res.status(500).json({
          success: false,
          error: '流式响应错误',
          details: error.message
        });
      }
      res.end();
    });

    // 超时处理
    const timeout = setTimeout(() => {
      if (!dataReceived) {
        console.error('⏰ 响应超时');
        res.status(504).json({
          success: false,
          error: '请求超时',
          details: '服务器响应超时，请稍后重试'
        });
      }
    }, 60000); // 60秒超时

    response.body.on('end', () => {
      clearTimeout(timeout);
    });

  } catch (error) {
    console.error('❌ 聊天请求错误:', error);
    res.status(500).json({ 
      success: false,
      error: '聊天请求失败', 
      details: error.message 
    });
  }
});

/**
 * 发送聊天消息到 Dify 工作流 (兼容旧接口)
 * POST /dify/chat
 */
router.post('/chat', async (req, res) => {
  // 直接调用 chat-messages 路由处理
  return router.handle(req, res, () => {
    req.url = '/chat-messages';
    router(req, res);
  });
});

/**
 * 获取对话历史
 * GET /dify/conversations/:conversationId
 */
router.get('/conversations/:conversationId', async (req, res) => {
  try {
    const { conversationId } = req.params;
    
    console.log('📜 获取对话历史:', conversationId);

    const response = await fetch(`${DIFY_API_BASE_URL}/conversations/${conversationId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${DIFY_API_KEY}`,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      const errorText = await response.text();
      console.error('❌ 获取对话历史失败:', errorText);
      throw new Error(`API 错误: ${response.status} ${errorText}`);
    }

    const result = await response.json();
    console.log('✅ 对话历史获取成功');

    res.json({
      success: true,
      data: result
    });

  } catch (error) {
    console.error('❌ 获取对话历史错误:', error);
    res.status(500).json({
      success: false,
      error: '获取对话历史失败',
      details: error.message
    });
  }
});

/**
 * 健康检查接口
 * GET /dify/health
 */
router.get('/health', (req, res) => {
  res.json({ 
    success: true,
    status: 'ok', 
    timestamp: new Date().toISOString(),
    difyApiUrl: DIFY_API_BASE_URL,
    service: 'Dify Chat Backend',
    version: '1.0.0'
  });
});



/**
 * 获取支持的文件类型
 * GET /dify/supported-types
 */
router.get('/supported-types', (req, res) => {
  res.json({
    success: true,
    supportedTypes: [
      // 图片格式
      'image/jpeg',
      'image/jpg', 
      'image/png',
      'image/gif',
      'image/webp',
      // 文档格式
      'application/pdf',
      'application/msword',
      'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
    ],
    maxFileSize: '10MB',
    description: '支持图片和文档格式，最大文件大小10MB'
  });
});



// 错误处理中间件
router.use((error, req, res, next) => {
  console.error('🚨 Dify 路由错误:', error);
  
  if (error instanceof multer.MulterError) {
    if (error.code === 'LIMIT_FILE_SIZE') {
      return res.status(400).json({
        success: false,
        error: '文件大小超出限制',
        details: '文件大小不能超过 10MB'
      });
    }
  }
  
  res.status(500).json({ 
    success: false,
    error: '服务器内部错误', 
    details: error.message 
  });
});

module.exports = router;